
import pandas as pd
import numpy as np
import xgboost as xgb
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.pipeline import make_pipeline
from sklearn.linear_model import LassoCV
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score
from scipy.stats import entropy


# Importing the cleaned and preprocessed Our World in Data COVID-19 dataset 
df = pd.read_csv("C:/Users/marco/Downloads/covid-data-cleaned.csv")
df


# Showing the pairings of countries based on total population (13 pairs of countries)
df_Austria = df[(df.location == "Austria")]
df_Switzerland = df[(df.location == "Switzerland")]

df_Belgium = df[(df.location == "Belgium")]
df_Canada = df[(df.location == "Canada")]

df_Bulgaria = df[(df.location == "Bulgaria")]
df_Serbia = df[(df.location == "Serbia")]

df_Cyprus = df[(df.location == "Cyprus")]
df_Luxembourg = df[(df.location == "Luxembourg")]

df_Czechia = df[(df.location == "Czechia")]
df_Romania = df[(df.location == "Romania")]

df_Denmark = df[(df.location == "Denmark")]
df_Ireland = df[(df.location == "Ireland")]

df_Estonia = df[(df.location == "Estonia")]
df_Latvia = df[(df.location == "Latvia")]

df_Finland = df[(df.location == "Finland")]
df_Iceland = df[(df.location == "Iceland")]

df_France = df[(df.location == "France")]
df_Italy = df[(df.location == "Italy")]

df_Netherlands = df[(df.location == "Netherlands")]
df_Sweden = df[(df.location == "Sweden")]

df_Portugal = df[(df.location == "Portugal")]
df_Spain = df[(df.location == "Spain")]

df_Slovakia = df[(df.location == "Slovakia")]
df_Slovenia = df[(df.location == "Slovenia")]

df_UnitedKingdom = df[(df.location == "United Kingdom")]
df_UnitedStates = df[(df.location == "United States")]


df_UnitedKingdom_new = df_UnitedKingdom.tail(-2)


# Concatenate individual country dataframes by using the first country from each defined pair above and combining all those countries into a single dataframe
dataframes = [df_Austria, df_Belgium, df_Bulgaria, df_Cyprus, df_Czechia, df_Denmark, df_Estonia, df_Finland, df_France, df_Netherlands, df_Portugal, df_Slovakia, df_UnitedKingdom_new, df_Switzerland, df_Canada, df_Serbia, df_Luxembourg, df_Romania, df_Ireland, df_Latvia, df_Iceland, df_Italy, df_Sweden, df_Spain, df_Slovenia, df_UnitedStates]
dataframe_one = pd.concat(dataframes)

# Exporting final_dataframe to CSV file
dataframe_one.to_csv("dataframe-one.csv")


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Austria'
country2 = 'Switzerland'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 7 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 7  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9991699923252158


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0013425167575155834
R2 Score: 0.9992626021702602
RMSE: 0.036640
Entropy Value: 0.00019452803666383865


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Austria'
country2 = 'Switzerland'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 3 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 5  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9974454800061979


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0020885572459370403
R2 Score: 0.9988528280397101
RMSE: 0.045701
Entropy Value: 0.0004103351755030901


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Belgium'
country2 = 'Canada'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 3 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 7  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9989190282407456


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.015185943246172551
R2 Score: 0.9988516813120202
RMSE: 0.123231
Entropy Value: 0.0003900318909582723


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Belgium'
country2 = 'Canada'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 3 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 5  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9987706326919069


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.018375766572997825
R2 Score: 0.9986104757656693
RMSE: 0.135557
Entropy Value: 0.0005417545801711733


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Bulgaria'
country2 = 'Serbia'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 3 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 7  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9604734653614051


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0021235139380423036
R2 Score: 0.9989608533920085
RMSE: 0.046082
Entropy Value: 0.00020835376815230597


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Bulgaria'
country2 = 'Serbia'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 3 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 5  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9604140465460519


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.006126929070284454
R2 Score: 0.9970017726529921
RMSE: 0.078275
Entropy Value: 0.0006566407159103827


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Cyprus'
country2 = 'Luxembourg'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 3 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 7  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9949062193563151


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0010948126043919594
R2 Score: 0.9971226073313326
RMSE: 0.033088
Entropy Value: 0.0007353489441030162


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Cyprus'
country2 = 'Luxembourg'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 3 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 5  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9949940053151926


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0014876690956331902
R2 Score: 0.9960900996828079
RMSE: 0.038570
Entropy Value: 0.0011182439482911944


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Czechia'
country2 = 'Romania'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 3 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 7  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9987279834799028


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0035563501611279766
R2 Score: 0.9975591549551829
RMSE: 0.059635
Entropy Value: 0.00035041497875719764


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Czechia'
country2 = 'Romania'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 3 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 5  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9980242375402296


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0037624148328907537
R2 Score: 0.9974177257060381
RMSE: 0.061339
Entropy Value: inf


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Denmark'
country2 = 'Ireland'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 3 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 7  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9991336553758403


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0039824430069437
R2 Score: 0.9985146782977569
RMSE: 0.063107
Entropy Value: 0.00082019994222745


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Denmark'
country2 = 'Ireland'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 3 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 5  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9989935922633931


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0036179936828483242
R2 Score: 0.9986506060409794
RMSE: 0.060150
Entropy Value: 0.000665447331955437


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Estonia'
country2 = 'Latvia'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 3 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 7  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9983509839471967


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0011442225986659504
R2 Score: 0.998102656857225
RMSE: 0.033826
Entropy Value: inf


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Estonia'
country2 = 'Latvia'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 3 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 5  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9988172536777192


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0011498507246205968
R2 Score: 0.9980933243320684
RMSE: 0.033909
Entropy Value: inf


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Finland'
country2 = 'Iceland'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 3 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 7  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9967115293459013


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.002631359506918055
R2 Score: 0.9977846875396988
RMSE: 0.051297
Entropy Value: 0.0008231147347694647


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Finland'
country2 = 'Iceland'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 3 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 5  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9968002075493546


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0025838187798911654
R2 Score: 0.9978247115518787
RMSE: 0.050831
Entropy Value: 0.0013343036085185639


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'France'
country2 = 'Italy'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 3 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 7  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9974380799964881


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.04203231904296749
R2 Score: 0.9977496670068304
RMSE: 0.205018
Entropy Value: 0.001029589932983813


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'France'
country2 = 'Italy'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 3 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 5  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.997212894312281


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.05589325373552914
R2 Score: 0.9970075780770488
RMSE: 0.236418
Entropy Value: 0.0014961704290713798


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Netherlands'
country2 = 'Sweden'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 3 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 7  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9974557008389675


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.009632293525443848
R2 Score: 0.9990787800266875
RMSE: 0.098144
Entropy Value: 0.0005803548472550031


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Netherlands'
country2 = 'Sweden'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 3 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 5  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9990746310006573


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.01681748604978763
R2 Score: 0.9983915975972862
RMSE: 0.129682
Entropy Value: 0.0005547247075158208


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Portugal'
country2 = 'Spain'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 3 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 7  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9991285362384288


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.012129239818308182
R2 Score: 0.9977801811586169
RMSE: 0.110133
Entropy Value: 0.0005886831079683492


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Portugal'
country2 = 'Spain'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 3 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 5  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9983792131946579


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.010138589742890305
R2 Score: 0.9981444976871221
RMSE: 0.100691
Entropy Value: 0.0005635017566477138


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Slovakia'
country2 = 'Slovenia'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 3 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 7  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9984789767307959


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0027083668308768272
R2 Score: 0.9986712195046868
RMSE: 0.052042
Entropy Value: 0.00047135693736216383


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Slovakia'
country2 = 'Slovenia'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 3 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 5  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.998514703095446


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.005931900948646389
R2 Score: 0.9970896873382034
RMSE: 0.077019
Entropy Value: 0.0007898893113525947


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'United Kingdom'
country2 = 'United States'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 3 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 7  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9573756200168303


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  3.067522668688002
R2 Score: 0.8735128665771991
RMSE: 1.751434
Entropy Value: 0.00997828364305316


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'United Kingdom'
country2 = 'United States'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 3 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 5  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0.2, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9555599032367461


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  1.3831340557751377
R2 Score: 0.9429674428683925
RMSE: 1.176067
Entropy Value: 0.007189751715215273


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Country Pair by Pair Analysis relative to cardiovascular death rate


# Importing the cleaned and preprocessed Our World in Data COVID-19 dataset 
df = pd.read_csv("C:/Users/marco/Downloads/covid-data-cleaned.csv")
df


# Showing the pairings of countries based on cardiovascular death rate (13 pairs of countries)
df_Austria = df[(df.location == "Austria")]
df_Belgium = df[(df.location == "Belgium")]

df_Canada = df[(df.location == "Canada")]
df_Cyprus = df[(df.location == "Cyprus")]

df_Denmark = df[(df.location == "Denmark")]
df_Finland = df[(df.location == "Finland")]

df_France = df[(df.location == "France")]
df_Iceland = df[(df.location == "Iceland")]

df_Ireland = df[(df.location == "Ireland")]
df_Italy = df[(df.location == "Italy")]

df_Luxembourg = df[(df.location == "Luxembourg")]
df_Netherlands = df[(df.location == "Netherlands")]

df_Portugal = df[(df.location == "Portugal")]
df_Spain = df[(df.location == "Spain")]

df_Sweden = df[(df.location == "Sweden")]
df_Switzerland = df[(df.location == "Switzerland")]

df_UnitedKingdom = df[(df.location == "United Kingdom")]
df_UnitedStates = df[(df.location == "United States")]

df_Czechia = df[(df.location == "Czechia")]
df_Estonia = df[(df.location == "Estonia")]

df_Slovakia = df[(df.location == "Slovakia")]
df_Slovenia = df[(df.location == "Slovenia")]

df_Bulgaria = df[(df.location == "Bulgaria")]
df_Latvia = df[(df.location == "Latvia")]

df_Romania = df[(df.location == "Romania")]
df_Serbia = df[(df.location == "Serbia")]


df_UnitedKingdom_new = df_UnitedKingdom.tail(-2)


# Concatenate individual country dataframes by using the first country from each defined pair above and combining all those countries into a single dataframe
dataframes = [df_Austria, df_Belgium, df_Bulgaria, df_Cyprus, df_Czechia, df_Denmark, df_Estonia, df_Finland, df_France, df_Netherlands, df_Portugal, df_Slovakia, df_UnitedKingdom_new, df_Switzerland, df_Canada, df_Serbia, df_Luxembourg, df_Romania, df_Ireland, df_Latvia, df_Iceland, df_Italy, df_Sweden, df_Spain, df_Slovenia, df_UnitedStates]
dataframe_one = pd.concat(dataframes)

# Exporting final_dataframe to CSV file
dataframe_one.to_csv("dataframe-one.csv")


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Austria'
country2 = 'Belgium'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.998456196460482


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.016140462125189346
R2 Score: 0.9986367589447218
RMSE: 0.127045
Entropy Value: 0.0007186737813811423


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Austria'
country2 = 'Belgium'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9985453142557521


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.01731215895223598
R2 Score: 0.9985377961513036
RMSE: 0.131576
Entropy Value: 0.000755209259742723


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Canada'
country2 = 'Cyprus'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9989867496016483


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0028020652544185898
R2 Score: 0.9991762074874513
RMSE: 0.052935
Entropy Value: 0.0003290685489915789


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Canada'
country2 = 'Cyprus'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9989605271130995


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.002685282233557505
R2 Score: 0.999210541084082
RMSE: 0.051820
Entropy Value: 0.00034527877599041973


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Denmark'
country2 = 'Finland'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9987252225958365


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.010232434979697452
R2 Score: 0.9941953413231738
RMSE: 0.101155
Entropy Value: 0.0021676176101701077


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Denmark'
country2 = 'Finland'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9984953654596765


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.008136863131264145
R2 Score: 0.9953841179278682
RMSE: 0.090205
Entropy Value: 0.0015398143907589235


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'France'
country2 = 'Iceland'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9946592139246286


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.053596386319007226
R2 Score: 0.9957380613117373
RMSE: 0.231509
Entropy Value: 0.0014569645741554262


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'France'
country2 = 'Iceland'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9946715554617531


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.06349754860870421
R2 Score: 0.9949507293753999
RMSE: 0.251987
Entropy Value: 0.002273841175109527


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Ireland'
country2 = 'Italy'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9989070959122885


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.005371809550427108
R2 Score: 0.9995586936801555
RMSE: 0.073293
Entropy Value: 0.00023323823646080252


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Ireland'
country2 = 'Italy'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9988984971748192


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.009889496543689754
R2 Score: 0.9991875554626719
RMSE: 0.099446
Entropy Value: 0.00044270709478587373


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Luxembourg'
country2 = 'Netherlands'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9989525073226527


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.004874464208163757
R2 Score: 0.9993646974648677
RMSE: 0.069817
Entropy Value: 0.0008434937353807828


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Luxembourg'
country2 = 'Netherlands'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9987243093178199


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.007716113263742701
R2 Score: 0.9989943374064345
RMSE: 0.087841
Entropy Value: 0.0017161933932385992


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Portugal'
country2 = 'Spain'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9987444044994997


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.006938078296368985
R2 Score: 0.9987302355995943
RMSE: 0.083295
Entropy Value: 0.0004794443988216877


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Portugal'
country2 = 'Spain'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9982848456743826


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.011554150205913471
R2 Score: 0.9978854305210006
RMSE: 0.107490
Entropy Value: 0.0006584258574244559


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Sweden'
country2 = 'Switzerland'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9984333716901233


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.015931239549295276
R2 Score: 0.9969563630033106
RMSE: 0.126219
Entropy Value: 0.0006754021628688348


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Sweden'
country2 = 'Switzerland'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9985258910599774


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.009780822718122402
R2 Score: 0.9981313899781104
RMSE: 0.098898
Entropy Value: 0.0007038834783452404


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'United Kingdom'
country2 = 'United States'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0.1, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9572922428501809


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  1.3971853498164353
R2 Score: 0.9423880476703369
RMSE: 1.182026
Entropy Value: 0.006984034800282115


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'United Kingdom'
country2 = 'United States'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0.2, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9566213518011253


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.713063858863409
R2 Score: 0.9705973147727024
RMSE: 0.844431
Entropy Value: 0.008268179051644176


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Czechia'
country2 = 'Estonia'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9987100560424087


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0010058615170550663
R2 Score: 0.9985394731187587
RMSE: 0.031715
Entropy Value: 0.0002910800367932633


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Czechia'
country2 = 'Estonia'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9982992559865769


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0013297376906791
R2 Score: 0.9980691997762051
RMSE: 0.036466
Entropy Value: inf


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Slovakia'
country2 = 'Slovenia'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9984547895987792


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.002902405614533229
R2 Score: 0.9985760200848308
RMSE: 0.053874
Entropy Value: 0.0005018366914602828


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Slovakia'
country2 = 'Slovenia'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9979685572320796


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.010286891805743988
R2 Score: 0.994953039214247
RMSE: 0.101424
Entropy Value: 0.001005217028297138


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Bulgaria'
country2 = 'Latvia'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9581157049903706


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0020134595466409933
R2 Score: 0.9988351175179158
RMSE: 0.044872
Entropy Value: 0.0002481296115330379


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Bulgaria'
country2 = 'Latvia'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9564879049798748


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0038412225079292634
R2 Score: 0.9977776693767008
RMSE: 0.061978
Entropy Value: 0.0004044101196355003


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Romania'
country2 = 'Serbia'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['diabetes_prevalence', 'female_smokers', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9982335652486138


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0015563262679148646
R2 Score: 0.9990938937518747
RMSE: 0.039450
Entropy Value: 0.0004499334264955072


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Romania'
country2 = 'Serbia'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9979474526774726


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.002076185405706244
R2 Score: 0.9987912273877525
RMSE: 0.045565
Entropy Value: 0.00045853981129780964


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Country Pair by Pair Analysis relative to male smokers


# Importing the cleaned and preprocessed Our World in Data COVID-19 dataset 
df = pd.read_csv("C:/Users/marco/Downloads/covid-data-cleaned.csv")
df


# Showing the pairings of countries based on male smokers (13 pairs of countries)
df_Canada = df[(df.location == "Canada")]
df_Denmark = df[(df.location == "Denmark")]

df_Finland = df[(df.location == "Finland")]
df_Iceland = df[(df.location == "Iceland")]

df_Ireland = df[(df.location == "Ireland")]
df_Luxembourg = df[(df.location == "Luxembourg")]

df_Netherlands = df[(df.location == "Netherlands")]
df_Slovenia = df[(df.location == "Slovenia")]

df_Sweden = df[(df.location == "Sweden")]
df_UnitedKingdom = df[(df.location == "United Kingdom")]

df_UnitedStates = df[(df.location == "United States")]
df_Austria = df[(df.location == "Austria")]

df_Belgium = df[(df.location == "Belgium")]
df_Czechia = df[(df.location == "Czechia")]

df_Estonia = df[(df.location == "Estonia")]
df_France = df[(df.location == "France")]

df_Italy = df[(df.location == "Italy")]
df_Portugal = df[(df.location == "Portugal")]

df_Romania = df[(df.location == "Romania")]
df_Serbia = df[(df.location == "Serbia")]

df_Slovakia = df[(df.location == "Slovakia")]
df_Spain = df[(df.location == "Spain")]

df_Switzerland = df[(df.location == "Switzerland")]
df_Bulgaria = df[(df.location == "Bulgaria")]

df_Cyprus = df[(df.location == "Cyprus")]
df_Latvia = df[(df.location == "Latvia")]


df_UnitedKingdom_new = df_UnitedKingdom.tail(-2)


# Concatenate individual country dataframes by using the first country from each defined pair above and combining all those countries into a single dataframe
dataframes = [df_Austria, df_Belgium, df_Bulgaria, df_Cyprus, df_Czechia, df_Denmark, df_Estonia, df_Finland, df_France, df_Netherlands, df_Portugal, df_Slovakia, df_UnitedKingdom_new, df_Switzerland, df_Canada, df_Serbia, df_Luxembourg, df_Romania, df_Ireland, df_Latvia, df_Iceland, df_Italy, df_Sweden, df_Spain, df_Slovenia, df_UnitedStates]
dataframe_one = pd.concat(dataframes)

# Exporting final_dataframe to CSV file
dataframe_one.to_csv("dataframe-one.csv")


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Canada'
country2 = 'Denmark'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9991198472250268


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0035622981531189114
R2 Score: 0.999149818574882
RMSE: 0.059685
Entropy Value: 0.000330791989058651


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Canada'
country2 = 'Denmark'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9987973362067224


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0034098009007722373
R2 Score: 0.9991862137124461
RMSE: 0.058394
Entropy Value: 0.00042828048166675814


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Finland'
country2 = 'Iceland'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9976265506566767


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.002104558864221546
R2 Score: 0.9982281951732214
RMSE: 0.045875
Entropy Value: 0.0006809600254822203


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Finland'
country2 = 'Iceland'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9972033148176618


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.004836890703946099
R2 Score: 0.9959278752229046
RMSE: 0.069548
Entropy Value: 0.0012304204035138641


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Ireland'
country2 = 'Luxembourg'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9987986251987184


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0017173908797679875
R2 Score: 0.9992479140176413
RMSE: 0.041441
Entropy Value: 0.00039280120442968804


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Ireland'
country2 = 'Luxembourg'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9986051830769147


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0015122598797065847
R2 Score: 0.9993377457219498
RMSE: 0.038888
Entropy Value: 0.0003022118010805689


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Netherlands'
country2 = 'Slovenia'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9992962940278153


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.006026879845882446
R2 Score: 0.9992643953405248
RMSE: 0.077633
Entropy Value: 0.0003719429700690147


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Netherlands'
country2 = 'Slovenia'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9991623229575961


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0044516891807437255
R2 Score: 0.9994566536271454
RMSE: 0.066721
Entropy Value: 0.00032994017253004367


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Sweden'
country2 = 'United Kingdom'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0.2, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9588473335928803


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.47227318644134914
R2 Score: 0.9826662059026536
RMSE: 0.687221
Entropy Value: 0.0030797153679582856


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Sweden'
country2 = 'United Kingdom'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9546833804604962


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.997926932618917
R2 Score: 0.9633731906218204
RMSE: 0.998963
Entropy Value: 0.005106077515730719


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'United States'
country2 = 'Austria'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.983794331453694


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.00854869651988359
R2 Score: 0.9945310004412267
RMSE: 0.092459
Entropy Value: 0.0006678574833760092


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'United States'
country2 = 'Austria'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9887577648734872


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.00406836830426948
R2 Score: 0.9973972751975432
RMSE: 0.063784
Entropy Value: 0.0005141467774508717


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Belgium'
country2 = 'Czechia'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9987378590313624


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.012446433855461606
R2 Score: 0.9988990709156199
RMSE: 0.111564
Entropy Value: 0.0005707690311533189


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Belgium'
country2 = 'Czechia'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.998309889655373


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.014806362040415705
R2 Score: 0.9986903273023058
RMSE: 0.121681
Entropy Value: 0.0008238184433236955


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Estonia'
country2 = 'France'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9972748488300354


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.06576710142677315
R2 Score: 0.9931527190173807
RMSE: 0.256451
Entropy Value: 0.003671594073428902


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Estonia'
country2 = 'France'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9978195582971618


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.07504882607957856
R2 Score: 0.9921863608333906
RMSE: 0.273950
Entropy Value: 0.004313799679754843


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Italy'
country2 = 'Portugal'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9993040710802911


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.02093963561387409
R2 Score: 0.9981619530362098
RMSE: 0.144705
Entropy Value: 0.0012838103910311198


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Italy'
country2 = 'Portugal'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9992988336861244


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.013594354001948517
R2 Score: 0.9988067098416261
RMSE: 0.116595
Entropy Value: 0.0007082932658725094


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Romania'
country2 = 'Serbia'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9985721206840632


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.001614404165662264
R2 Score: 0.9990600803111381
RMSE: 0.040180
Entropy Value: 0.00041066443993060793


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Romania'
country2 = 'Serbia'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9979474526774726


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.002076185405706244
R2 Score: 0.9987912273877525
RMSE: 0.045565
Entropy Value: 0.00045853981129780964


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Slovakia'
country2 = 'Spain'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9994767987719648


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0015014430402105537
R2 Score: 0.9997248669986107
RMSE: 0.038748
Entropy Value: 0.00014000658074544682


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Slovakia'
country2 = 'Spain'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9988021206356716


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.006694095157429868
R2 Score: 0.99877333575572
RMSE: 0.081817
Entropy Value: 0.00048549470785567154


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Switzerland'
country2 = 'Bulgaria'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9661827427503995


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.00378049910950887
R2 Score: 0.9984788009596705
RMSE: 0.061486
Entropy Value: 0.00038857518870859817


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Switzerland'
country2 = 'Bulgaria'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9660124510295903


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0036559826087191843
R2 Score: 0.9985289039688287
RMSE: 0.060465
Entropy Value: 0.00028880483478410657


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Cyprus'
country2 = 'Latvia'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9968381533668923


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0007853700061385886
R2 Score: 0.9984435932019353
RMSE: 0.028024
Entropy Value: 0.00041728333907532875


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Cyprus'
country2 = 'Latvia'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9965848123547593


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0010839291039479871
R2 Score: 0.9978519237902916
RMSE: 0.032923
Entropy Value: 0.000511041568557603


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Country Pair by Pair Analysis relative to female smokers


# Importing the cleaned and preprocessed Our World in Data COVID-19 dataset 
df = pd.read_csv("C:/Users/marco/Downloads/covid-data-cleaned.csv")
df


# Showing the pairings of countries based on female smokers (13 pairs of countries)
df_Canada = df[(df.location == "Canada")]
df_Cyprus = df[(df.location == "Cyprus")]

df_Denmark = df[(df.location == "Denmark")]
df_Finland = df[(df.location == "Finland")]

df_Iceland = df[(df.location == "Iceland")]
df_Italy = df[(df.location == "Italy")]

df_Portugal = df[(df.location == "Portugal")]
df_Slovenia = df[(df.location == "Slovenia")]

df_Sweden = df[(df.location == "Sweden")]
df_UnitedKingdom = df[(df.location == "United Kingdom")]

df_UnitedStates = df[(df.location == "United States")]
df_Austria = df[(df.location == "Austria")]

df_Belgium = df[(df.location == "Belgium")]
df_Estonia = df[(df.location == "Estonia")]

df_Ireland = df[(df.location == "Ireland")]
df_Latvia = df[(df.location == "Latvia")]

df_Luxembourg = df[(df.location == "Luxembourg")]
df_Netherlands = df[(df.location == "Netherlands")]

df_Romania = df[(df.location == "Romania")]
df_Slovakia = df[(df.location == "Slovakia")]

df_Spain = df[(df.location == "Spain")]
df_Switzerland = df[(df.location == "Switzerland")]

df_Bulgaria= df[(df.location == "Bulgaria")]
df_Czechia = df[(df.location == "Czechia")]

df_France = df[(df.location == "France")]
df_Serbia = df[(df.location == "Serbia")]


df_UnitedKingdom_new = df_UnitedKingdom.tail(-2)


# Concatenate individual country dataframes by using the first country from each defined pair above and combining all those countries into a single dataframe
dataframes = [df_Austria, df_Belgium, df_Bulgaria, df_Cyprus, df_Czechia, df_Denmark, df_Estonia, df_Finland, df_France, df_Netherlands, df_Portugal, df_Slovakia, df_UnitedKingdom_new, df_Switzerland, df_Canada, df_Serbia, df_Luxembourg, df_Romania, df_Ireland, df_Latvia, df_Iceland, df_Italy, df_Sweden, df_Spain, df_Slovenia, df_UnitedStates]
dataframe_one = pd.concat(dataframes)

# Exporting final_dataframe to CSV file
dataframe_one.to_csv("dataframe-one.csv")


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Canada'
country2 = 'Cyprus'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9989396252151874


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0023675274789805804
R2 Score: 0.9993039593180916
RMSE: 0.048657
Entropy Value: 0.0002917411838061955


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Canada'
country2 = 'Cyprus'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9989605271130995


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.002685282233557505
R2 Score: 0.999210541084082
RMSE: 0.051820
Entropy Value: 0.00034527877599041973


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Denmark'
country2 = 'Finland'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9987535557486945


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.007569049722669286
R2 Score: 0.9957062272826365
RMSE: 0.087000
Entropy Value: inf


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Denmark'
country2 = 'Finland'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9984953654596765


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.008136863131264145
R2 Score: 0.9953841179278682
RMSE: 0.090205
Entropy Value: 0.0015398143907589235


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Iceland'
country2 = 'Italy'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9993163648274013


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.015447420587881813
R2 Score: 0.9987332719640899
RMSE: 0.124288
Entropy Value: 0.0007928936109947494


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Iceland'
country2 = 'Italy'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9994138916027948


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.03290481728582324
R2 Score: 0.9973017207413157
RMSE: 0.181397
Entropy Value: 0.0017395706724272842


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Portugal'
country2 = 'Slovenia'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9986102850111352


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0023723489330236868
R2 Score: 0.9988124530308832
RMSE: 0.048707
Entropy Value: 0.0002848751285545325


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Portugal'
country2 = 'Slovenia'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9987931112255966


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.002719376915070921
R2 Score: 0.9986387382697272
RMSE: 0.052148
Entropy Value: 0.00030312420047472904


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Sweden'
country2 = 'United Kingdom'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0.2, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9583436207367914


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.3215249530704957
R2 Score: 0.9881991027784613
RMSE: 0.567032
Entropy Value: 0.002642072340961003


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Sweden'
country2 = 'United Kingdom'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9546833804604962


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.997926932618917
R2 Score: 0.9633731906218204
RMSE: 0.998963
Entropy Value: 0.005106077515730719


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'United States'
country2 = 'Austria'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9871989498238769


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0060186676398561656
R2 Score: 0.9961495778227457
RMSE: 0.077580
Entropy Value: 0.0005991889258687465


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'United States'
country2 = 'Austria'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9887577648734872


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.00406836830426948
R2 Score: 0.9973972751975432
RMSE: 0.063784
Entropy Value: 0.0005141467774508717


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Belgium'
country2 = 'Estonia'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9988940139433922


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.014213131068063751
R2 Score: 0.9988739751027007
RMSE: 0.119219
Entropy Value: 0.0008755638819072048


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Belgium'
country2 = 'Estonia'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9985104636986213


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.012715196293674761
R2 Score: 0.9989926478879171
RMSE: 0.112762
Entropy Value: 0.0008232624023628059


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Ireland'
country2 = 'Latvia'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9985163505355373


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0019485868775483287
R2 Score: 0.9991159573277734
RMSE: 0.044143
Entropy Value: 0.00044838336973350434


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Ireland'
country2 = 'Latvia'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9984706478843881


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0019969715660626214
R2 Score: 0.9990940059691648
RMSE: 0.044687
Entropy Value: 0.0003069312117218654


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Luxembourg'
country2 = 'Netherlands'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9990232848825181


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.005227635293595947
R2 Score: 0.9993186676908599
RMSE: 0.072302
Entropy Value: 0.0006067133512587061


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Luxembourg'
country2 = 'Netherlands'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9987243093178199


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.007716113263742701
R2 Score: 0.9989943374064345
RMSE: 0.087841
Entropy Value: 0.0017161933932385992


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Romania'
country2 = 'Slovakia'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9989475810367674


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0009858239346901049
R2 Score: 0.9994441257129435
RMSE: 0.031398
Entropy Value: 0.00012076580400027207


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Romania'
country2 = 'Slovakia'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.998030341444381


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.0026098629278783294
R2 Score: 0.99852838256072
RMSE: 0.051087
Entropy Value: 0.0004080770571716045


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Spain'
country2 = 'Switzerland'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9991186723177916


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.005248655333758953
R2 Score: 0.9991504781499669
RMSE: 0.072448
Entropy Value: inf


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Spain'
country2 = 'Switzerland'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9987177894783118


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.008170528399905543
R2 Score: 0.9986775579723456
RMSE: 0.090391
Entropy Value: 0.0007620940166931194


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Bulgaria'
country2 = 'Czechia'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9561647329294217


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.002649612864395656
R2 Score: 0.9983839393744748
RMSE: 0.051474
Entropy Value: 0.00027256482883888917


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Bulgaria'
country2 = 'Czechia'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9555145568773449


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.002769256603078144
R2 Score: 0.9983109658703929
RMSE: 0.052624
Entropy Value: 0.00028051806238002606


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'France'
country2 = 'Serbia'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'male_smokers', 'life_expectancy', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9941440903988384


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.05493983728553627
R2 Score: 0.9952696565378223
RMSE: 0.234392
Entropy Value: 0.0017421697067628312


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'France'
country2 = 'Serbia'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9930827422814454


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.07948072065736031
R2 Score: 0.9931566759949306
RMSE: 0.281923
Entropy Value: 0.0020226363731710244


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Country Pair by Pair Analysis relative to life expectancy


# Importing the cleaned and preprocessed Our World in Data COVID-19 dataset 
df = pd.read_csv("C:/Users/marco/Downloads/covid-data-cleaned.csv")
df


# Showing the pairings of countries based on life expectancy (13 pairs of countries)
df_Austria = df[(df.location == "Austria")]
df_Belgium = df[(df.location == "Belgium")]

df_Canada = df[(df.location == "Canada")]
df_Cyprus = df[(df.location == "Cyprus")]

df_Denmark = df[(df.location == "Denmark")]
df_Finland = df[(df.location == "Finland")]

df_France = df[(df.location == "France")]
df_Iceland = df[(df.location == "Iceland")]

df_Ireland = df[(df.location == "Ireland")]
df_Italy = df[(df.location == "Italy")]

df_Luxembourg = df[(df.location == "Luxembourg")]
df_Netherlands = df[(df.location == "Netherlands")]

df_Portugal = df[(df.location == "Portugal")]
df_Slovenia = df[(df.location == "Slovenia")]

df_Spain = df[(df.location == "Spain")]
df_Sweden = df[(df.location == "Sweden")]

df_Switzerland = df[(df.location == "Switzerland")]
df_UnitedKingdom = df[(df.location == "United Kingdom")]

df_Czechia = df[(df.location == "Czechia")]
df_Estonia = df[(df.location == "Estonia")]

df_UnitedStates = df[(df.location == "United States")]
df_Bulgaria = df[(df.location == "Bulgaria")]

df_Latvia = df[(df.location == "Latvia")]
df_Romania = df[(df.location == "Romania")]

df_Serbia = df[(df.location == "Serbia")]
df_Slovakia = df[(df.location == "Slovakia")]


df_UnitedKingdom_new = df_UnitedKingdom.tail(-2)


# Concatenate individual country dataframes by using the first country from each defined pair above and combining all those countries into a single dataframe
dataframes = [df_Austria, df_Belgium, df_Bulgaria, df_Cyprus, df_Czechia, df_Denmark, df_Estonia, df_Finland, df_France, df_Netherlands, df_Portugal, df_Slovakia, df_UnitedKingdom_new, df_Switzerland, df_Canada, df_Serbia, df_Luxembourg, df_Romania, df_Ireland, df_Latvia, df_Iceland, df_Italy, df_Sweden, df_Spain, df_Slovenia, df_UnitedStates]
dataframe_one = pd.concat(dataframes)

# Exporting final_dataframe to CSV file
dataframe_one.to_csv("dataframe-one.csv")


# Importing the dataframe that includes the first countries in each pairing of countries from previous step
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Austria'
country2 = 'Belgium'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9986706695832035


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.01609753378306672
R2 Score: 0.998640384719372
RMSE: 0.126876
Entropy Value: 0.0006364314394538599


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Austria'
country2 = 'Belgium'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.9}
Best CV score: 0.9985453142557521


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.01731215895223598
R2 Score: 0.9985377961513036
RMSE: 0.131576
Entropy Value: 0.000755209259742723


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Canada'
country2 = 'Cyprus'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.999053878094869


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.002132122245038013
R2 Score: 0.9993731672242354
RMSE: 0.046175
Entropy Value: 0.00042462368096495684


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Canada'
country2 = 'Cyprus'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 5, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.9989605271130995


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.002685282233557505
R2 Score: 0.999210541084082
RMSE: 0.051820
Entropy Value: 0.00034527877599041973


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Denmark'
country2 = 'Finland'

# Extracting important features for XGBoost Model Analysis for the population health index
df_updated = df_updated[['location', 'date', 'cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'aged_65_older', 'median_age', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the population health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'aged_65_older', 'median_age'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['cardiovasc_death_rate', 'diabetes_prevalence', 'female_smokers', 'male_smokers', 'aged_65_older', 'median_age']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)


# Define XGBoost model
xgb_model = xgb.XGBRegressor()

# Define hyperparameters to tune
params = {'max_depth': [3, 4, 5],
          'learning_rate': [0.1, 0.01, 0.001],
          'n_estimators': [50, 100, 150],
          'gamma': [0, 0.1, 0.2],
          'subsample': [0.8, 0.9],
          'colsample_bytree': [0.8, 0.9]}


# Perform grid search and 10-fold cross-validation (k = 10)
grid_search = GridSearchCV(estimator=xgb_model, param_grid=params, cv=10, n_jobs=-1)
grid_search.fit(X_train_scaled, y_train)

# Print the best hyperparameters
print("Best hyperparameters:", grid_search.best_params_)
print('Best CV score:', grid_search.best_score_)

Best hyperparameters: {'colsample_bytree': 0.9, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 4, 'n_estimators': 150, 'subsample': 0.8}
Best CV score: 0.998779521821126


# Fit the model using the best hyperparameters
best_model = grid_search.best_estimator_
best_model.fit(X_train_scaled, y_train)

# Making Predictions
y_pred = best_model.predict(X_test_scaled)


# Evaluate the performance of the XG Boost Model by obtaining the Mean Squared Error (MSE), Root Mean Squared Error (RMSE), R^2 Score, and Entropy
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
score = r2_score(y_test, y_pred)
entropy_val = entropy(y_test, y_pred)
print("MSE: ", mse)
print('R2 Score:', score)
print("RMSE: %f" % (rmse))
print("Entropy Value:", entropy_val)

MSE:  0.008955815256083285
R2 Score: 0.9949195425294739
RMSE: 0.094635
Entropy Value: 0.0018700174545439696


feature_importances = best_model.feature_importances_
feature_importances = pd.DataFrame({'feature': selected_cols , 'importance': feature_importances})
feature_importances = feature_importances.sort_values('importance', ascending=False)
feature_importances


# Importing the dataframe of all 26 countries
df_updated = pd.read_csv("C:/Users/marco/Downloads/dataframe-one.csv")
df_updated


country1 = 'Denmark'
country2 = 'Finland'

# Extracting important features for XGBoost Model Analysis for the country health index
df_updated = df_updated[['location', 'date', 'hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population', 'Mortality Rate']]
df_updated = df_updated[df_updated['location'].isin([country1, country2])]


df_updated


'''
I need to create lagged variables for the previous day's mortality rate, the previous week's mortality rate, and the previous month's mortality rate. 
I can create these lagged variables using the shift() method in pandas in order to convert the Our World in Data COVID-19 timeseries dataset to a supervised learning problem so that the XGBoost Model can be used.
I need to transform the data into a tabular format where each row represents a single observation and each column represents a feature.
That is the reason why it is necessary to convert the timeseries dataset into a supervised learning problem in order for the XGBoost Model to be used directly to assess which variables are the highest predictors of COVID-19 mortality (death rate) per country.
'''
# Create lagged variables for the previous day mortality, previous week mortality, and previous month mortality rates, respectively
df_updated['prev_day_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(1)
df_updated['prev_week_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(7)
df_updated['prev_month_mortality'] = df_updated.groupby(['location'])['Mortality Rate'].shift(30)


# Replace NaN values in prev_day_mortality, prev_week_mortality, and prev_month_mortality columns with 0
df_updated['prev_day_mortality'] = df_updated['prev_day_mortality'].fillna(0)
df_updated['prev_week_mortality'] = df_updated['prev_week_mortality'].fillna(0)
df_updated['prev_month_mortality'] = df_updated['prev_month_mortality'].fillna(0)


# Performing Principal Component Analysis (PCA) in order to solve the problem of multi-collinearity
pca = PCA()
pca.fit(df_updated.iloc[:,2:])

PCA()

PCA()


# Setting the number of principal components to 6 as this equals the number of input variables for the XGBoost Model Analysis for the country health index
n_components = 6  # of input variables for XGBoost Model Analysis
principal_components = pca.transform(df_updated.iloc[:,2:])[:, :n_components]


# Obtaining the resulting dataframe after performing Principal Component Analysis for Dataframe
principal_df = pd.DataFrame(data=principal_components, columns=['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population'])
principal_df['location'] = df_updated['location'].values


# Convert categorical variables to numerical variables using one-hot encoding with the get_dummies() method
df_updated = pd.get_dummies(df_updated, columns=['location'])


selected_cols = ['hospital_beds_per_thousand', 'human_development_index', 'extreme_poverty', 'gdp_per_capita', 'population_density', 'population']
X = principal_df[selected_cols].values
y = df_updated['Mortality Rate'].values

# Split the dataset into training set and testing set for XGBoost Model
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)


# Fit scaling on the training set
scaler = StandardScaler()
scaler.fit(X_train)

StandardScaler()

StandardScaler()


# Apply scaling on the training set
X_train_scaled = scaler.transform(X_train)


# Apply scaling on the test set
X_test_scaled = scaler.transform(X_test)

	date	cardiovasc_death_rate	diabetes_prevalence	female_smokers	male_smokers	life_expectancy	aged_65_older	aged_70_older	median_age	hospital_beds_per_thousand	human_development_index	extreme_poverty	gdp_per_capita	population_density	population	stringency_index	Mortality Rate	location
0	2/25/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	11.11	0.000000	Austria
1	2/26/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	11.11	0.000000	Austria
2	2/27/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	11.11	0.000000	Austria
3	2/28/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	11.11	0.000000	Austria
4	2/29/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	11.11	0.000000	Austria
...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...
27269	12/25/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	23.18	1.086136	United States
27270	12/26/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	23.18	1.086032	United States
27271	12/27/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	23.18	1.085212	United States
27272	12/28/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	23.18	1.084986	United States
27273	12/29/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	23.18	1.084791	United States

	date	cardiovasc_death_rate	diabetes_prevalence	female_smokers	male_smokers	life_expectancy	aged_65_older	aged_70_older	median_age	hospital_beds_per_thousand	human_development_index	extreme_poverty	gdp_per_capita	population_density	population	Mortality Rate	location
0	2/25/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	0.000000	Austria
1	2/26/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	0.000000	Austria
2	2/27/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	0.000000	Austria
3	2/28/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	0.000000	Austria
4	2/29/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	0.000000	Austria
...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...
27267	12/25/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	1.086136	United States
27268	12/26/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	1.086032	United States
27269	12/27/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	1.085212	United States
27270	12/28/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	1.084986	United States
27271	12/29/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	1.084791	United States

	location	date	cardiovasc_death_rate	diabetes_prevalence	female_smokers	male_smokers	life_expectancy	aged_65_older	median_age	Mortality Rate
0	Austria	2/25/2020	145.183	6.35	28.4	30.9	81.54	19.202	44.4	0.000000
1	Austria	2/26/2020	145.183	6.35	28.4	30.9	81.54	19.202	44.4	0.000000
2	Austria	2/27/2020	145.183	6.35	28.4	30.9	81.54	19.202	44.4	0.000000
3	Austria	2/28/2020	145.183	6.35	28.4	30.9	81.54	19.202	44.4	0.000000
4	Austria	2/29/2020	145.183	6.35	28.4	30.9	81.54	19.202	44.4	0.000000
...	...	...	...	...	...	...	...	...	...	...
14644	Switzerland	12/25/2022	99.739	5.59	22.6	28.9	83.78	18.436	43.1	0.322922
14645	Switzerland	12/26/2022	99.739	5.59	22.6	28.9	83.78	18.436	43.1	0.322922
14646	Switzerland	12/27/2022	99.739	5.59	22.6	28.9	83.78	18.436	43.1	0.322922
14647	Switzerland	12/28/2022	99.739	5.59	22.6	28.9	83.78	18.436	43.1	0.323082
14648	Switzerland	12/29/2022	99.739	5.59	22.6	28.9	83.78	18.436	43.1	0.322149

	date	cardiovasc_death_rate	diabetes_prevalence	female_smokers	male_smokers	life_expectancy	aged_65_older	aged_70_older	median_age	hospital_beds_per_thousand	human_development_index	extreme_poverty	gdp_per_capita	population_density	population	Mortality Rate	location
0	2/25/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	0.000000	Austria
1	2/26/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	0.000000	Austria
2	2/27/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	0.000000	Austria
3	2/28/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	0.000000	Austria
4	2/29/2020	145.183	6.35	28.4	30.9	81.54	19.202	13.748	44.4	7.37	0.922	0.7	45436.686	106.749	8939617	0.000000	Austria
...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...
27267	12/25/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	1.086136	United States
27268	12/26/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	1.086032	United States
27269	12/27/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	1.085212	United States
27270	12/28/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	1.084986	United States
27271	12/29/2022	151.089	10.79	19.1	24.6	78.86	15.413	9.732	38.3	2.77	0.926	1.2	54225.446	35.608	338289856	1.084791	United States

	location	date	hospital_beds_per_thousand	human_development_index	extreme_poverty	gdp_per_capita	population_density	Mortality Rate
0	Austria	2/25/2020	7.37	0.922	0.70	45436.686	106.749	0.000000
1	Austria	2/26/2020	7.37	0.922	0.70	45436.686	106.749	0.000000
2	Austria	2/27/2020	7.37	0.922	0.70	45436.686	106.749	0.000000
3	Austria	2/28/2020	7.37	0.922	0.70	45436.686	106.749	0.000000
4	Austria	2/29/2020	7.37	0.922	0.70	45436.686	106.749	0.000000
...	...	...	...	...	...	...	...	...
14644	Switzerland	12/25/2022	4.53	0.955	0.03	57410.166	214.243	0.322922
14645	Switzerland	12/26/2022	4.53	0.955	0.03	57410.166	214.243	0.322922
14646	Switzerland	12/27/2022	4.53	0.955	0.03	57410.166	214.243	0.322922
14647	Switzerland	12/28/2022	4.53	0.955	0.03	57410.166	214.243	0.323082
14648	Switzerland	12/29/2022	4.53	0.955	0.03	57410.166	214.243	0.322149

	feature	importance
1	diabetes_prevalence	0.928385
6	median_age	0.045537
2	female_smokers	0.012387
0	cardiovasc_death_rate	0.009839
5	aged_65_older	0.002963
3	male_smokers	0.000738
4	life_expectancy	0.000151

	feature	importance
1	human_development_index	0.860290
0	hospital_beds_per_thousand	0.062671
2	extreme_poverty	0.042865
3	gdp_per_capita	0.032818
4	population_density	0.001356

	location	date	cardiovasc_death_rate	diabetes_prevalence	female_smokers	male_smokers	life_expectancy	aged_65_older	median_age	Mortality Rate
1039	Belgium	2/4/2020	114.898	4.29	25.1	31.4	81.63	18.571	41.8	0.000000
1040	Belgium	2/5/2020	114.898	4.29	25.1	31.4	81.63	18.571	41.8	0.000000
1041	Belgium	2/6/2020	114.898	4.29	25.1	31.4	81.63	18.571	41.8	0.000000
1042	Belgium	2/7/2020	114.898	4.29	25.1	31.4	81.63	18.571	41.8	0.000000
1043	Belgium	2/8/2020	114.898	4.29	25.1	31.4	81.63	18.571	41.8	0.000000
...	...	...	...	...	...	...	...	...	...	...
15716	Canada	12/25/2022	105.599	7.37	12.0	16.6	82.43	16.984	41.4	1.092509
15717	Canada	12/26/2022	105.599	7.37	12.0	16.6	82.43	16.984	41.4	1.092338
15718	Canada	12/27/2022	105.599	7.37	12.0	16.6	82.43	16.984	41.4	1.092196
15719	Canada	12/28/2022	105.599	7.37	12.0	16.6	82.43	16.984	41.4	1.092321
15720	Canada	12/29/2022	105.599	7.37	12.0	16.6	82.43	16.984	41.4	1.093162

	feature	importance
1	diabetes_prevalence	0.852780
0	cardiovasc_death_rate	0.064945
5	aged_65_older	0.033227
6	median_age	0.028916
2	female_smokers	0.016257
3	male_smokers	0.003580
4	life_expectancy	0.000296

	feature	importance
1	human_development_index	0.859285
0	hospital_beds_per_thousand	0.098572
2	extreme_poverty	0.027225
3	gdp_per_capita	0.013788
4	population_density	0.001130

	location	date	cardiovasc_death_rate	diabetes_prevalence	female_smokers	male_smokers	life_expectancy	aged_65_older	median_age	Mortality Rate
2099	Bulgaria	3/8/2020	424.688	5.81	30.1	44.4	75.05	20.801	44.7	0.000000
2100	Bulgaria	3/9/2020	424.688	5.81	30.1	44.4	75.05	20.801	44.7	0.000000
2101	Bulgaria	3/10/2020	424.688	5.81	30.1	44.4	75.05	20.801	44.7	0.000000
2102	Bulgaria	3/11/2020	424.688	5.81	30.1	44.4	75.05	20.801	44.7	14.285714
2103	Bulgaria	3/12/2020	424.688	5.81	30.1	44.4	75.05	20.801	44.7	14.285714
...	...	...	...	...	...	...	...	...	...	...
16754	Serbia	12/25/2022	439.415	10.08	37.7	40.2	76.00	17.366	41.2	0.717058
16755	Serbia	12/26/2022	439.415	10.08	37.7	40.2	76.00	17.366	41.2	0.716963
16756	Serbia	12/27/2022	439.415	10.08	37.7	40.2	76.00	17.366	41.2	0.716677
16757	Serbia	12/28/2022	439.415	10.08	37.7	40.2	76.00	17.366	41.2	0.716395
16758	Serbia	12/29/2022	439.415	10.08	37.7	40.2	76.00	17.366	41.2	0.716205

	feature	importance
0	cardiovasc_death_rate	0.583303
5	aged_65_older	0.190242
6	median_age	0.118268
2	female_smokers	0.043382
1	diabetes_prevalence	0.043157
4	life_expectancy	0.011155
3	male_smokers	0.010494

	feature	importance
0	hospital_beds_per_thousand	0.649173
1	human_development_index	0.179720
2	extreme_poverty	0.087485
4	population_density	0.042793
3	gdp_per_capita	0.040829

	location	date	cardiovasc_death_rate	diabetes_prevalence	female_smokers	male_smokers	life_expectancy	aged_65_older	median_age	Mortality Rate
3126	Cyprus	3/8/2020	141.171	9.24	19.6	52.7	80.98	13.416	37.3	0.000000
3127	Cyprus	3/9/2020	141.171	9.24	19.6	52.7	80.98	13.416	37.3	0.000000
3128	Cyprus	3/10/2020	141.171	9.24	19.6	52.7	80.98	13.416	37.3	0.000000
3129	Cyprus	3/11/2020	141.171	9.24	19.6	52.7	80.98	13.416	37.3	0.000000
3130	Cyprus	3/12/2020	141.171	9.24	19.6	52.7	80.98	13.416	37.3	0.000000
...	...	...	...	...	...	...	...	...	...	...
17795	Luxembourg	12/25/2022	128.275	4.42	20.9	26.0	82.25	14.312	39.7	0.377872
17796	Luxembourg	12/26/2022	128.275	4.42	20.9	26.0	82.25	14.312	39.7	0.377872
17797	Luxembourg	12/27/2022	128.275	4.42	20.9	26.0	82.25	14.312	39.7	0.377872
17798	Luxembourg	12/28/2022	128.275	4.42	20.9	26.0	82.25	14.312	39.7	0.377872
17799	Luxembourg	12/29/2022	128.275	4.42	20.9	26.0	82.25	14.312	39.7	0.377872

	feature	importance
1	diabetes_prevalence	0.692885
0	cardiovasc_death_rate	0.156869
6	median_age	0.062790
5	aged_65_older	0.033893
2	female_smokers	0.031649
3	male_smokers	0.012797
4	life_expectancy	0.009117

	location	date	cardiovasc_death_rate	diabetes_prevalence	female_smokers	male_smokers	life_expectancy	aged_65_older	median_age	Mortality Rate
4153	Czechia	3/1/2020	227.485	6.82	30.5	38.3	79.38	19.027	43.3	0.000000
4154	Czechia	3/2/2020	227.485	6.82	30.5	38.3	79.38	19.027	43.3	0.000000
4155	Czechia	3/3/2020	227.485	6.82	30.5	38.3	79.38	19.027	43.3	0.000000
4156	Czechia	3/4/2020	227.485	6.82	30.5	38.3	79.38	19.027	43.3	0.000000
4157	Czechia	3/5/2020	227.485	6.82	30.5	38.3	79.38	19.027	43.3	0.000000
...	...	...	...	...	...	...	...	...	...	...
18833	Romania	12/25/2022	370.946	9.74	22.9	37.1	76.05	17.850	43.0	2.037520
18834	Romania	12/26/2022	370.946	9.74	22.9	37.1	76.05	17.850	43.0	2.036403
18835	Romania	12/27/2022	370.946	9.74	22.9	37.1	76.05	17.850	43.0	2.036403
18836	Romania	12/28/2022	370.946	9.74	22.9	37.1	76.05	17.850	43.0	2.036403
18837	Romania	12/29/2022	370.946	9.74	22.9	37.1	76.05	17.850	43.0	2.036403

	location	date	hospital_beds_per_thousand	human_development_index	extreme_poverty	gdp_per_capita	population_density	Mortality Rate
4153	Czechia	3/1/2020	6.630	0.900	0.0	32605.906	137.176	0.000000
4154	Czechia	3/2/2020	6.630	0.900	0.0	32605.906	137.176	0.000000
4155	Czechia	3/3/2020	6.630	0.900	0.0	32605.906	137.176	0.000000
4156	Czechia	3/4/2020	6.630	0.900	0.0	32605.906	137.176	0.000000
4157	Czechia	3/5/2020	6.630	0.900	0.0	32605.906	137.176	0.000000
...	...	...	...	...	...	...	...	...
18833	Romania	12/25/2022	6.892	0.828	5.7	23313.199	85.129	2.037520
18834	Romania	12/26/2022	6.892	0.828	5.7	23313.199	85.129	2.036403
18835	Romania	12/27/2022	6.892	0.828	5.7	23313.199	85.129	2.036403
18836	Romania	12/28/2022	6.892	0.828	5.7	23313.199	85.129	2.036403
18837	Romania	12/29/2022	6.892	0.828	5.7	23313.199	85.129	2.036403

	location	date	cardiovasc_death_rate	diabetes_prevalence	female_smokers	male_smokers	life_expectancy	aged_65_older	median_age	Mortality Rate
5187	Denmark	2/2/2020	114.767	6.41	19.3	18.8	80.9	19.677	42.3	0.000000
5188	Denmark	2/3/2020	114.767	6.41	19.3	18.8	80.9	19.677	42.3	0.000000
5189	Denmark	2/4/2020	114.767	6.41	19.3	18.8	80.9	19.677	42.3	0.000000
5190	Denmark	2/5/2020	114.767	6.41	19.3	18.8	80.9	19.677	42.3	0.000000
5191	Denmark	2/6/2020	114.767	6.41	19.3	18.8	80.9	19.677	42.3	0.000000
...	...	...	...	...	...	...	...	...	...	...
19868	Ireland	12/25/2022	126.459	3.28	23.0	25.7	82.3	13.928	38.7	0.491388
19869	Ireland	12/26/2022	126.459	3.28	23.0	25.7	82.3	13.928	38.7	0.491388
19870	Ireland	12/27/2022	126.459	3.28	23.0	25.7	82.3	13.928	38.7	0.491388
19871	Ireland	12/28/2022	126.459	3.28	23.0	25.7	82.3	13.928	38.7	0.491388
19872	Ireland	12/29/2022	126.459	3.28	23.0	25.7	82.3	13.928	38.7	0.491388

	location	date	hospital_beds_per_thousand	human_development_index	extreme_poverty	gdp_per_capita	population_density	Mortality Rate
5187	Denmark	2/2/2020	2.50	0.940	0.2	46682.515	136.520	0.000000
5188	Denmark	2/3/2020	2.50	0.940	0.2	46682.515	136.520	0.000000
5189	Denmark	2/4/2020	2.50	0.940	0.2	46682.515	136.520	0.000000
5190	Denmark	2/5/2020	2.50	0.940	0.2	46682.515	136.520	0.000000
5191	Denmark	2/6/2020	2.50	0.940	0.2	46682.515	136.520	0.000000
...	...	...	...	...	...	...	...	...
19868	Ireland	12/25/2022	2.96	0.955	0.2	67335.293	69.874	0.491388
19869	Ireland	12/26/2022	2.96	0.955	0.2	67335.293	69.874	0.491388
19870	Ireland	12/27/2022	2.96	0.955	0.2	67335.293	69.874	0.491388
19871	Ireland	12/28/2022	2.96	0.955	0.2	67335.293	69.874	0.491388
19872	Ireland	12/29/2022	2.96	0.955	0.2	67335.293	69.874	0.491388

	feature	importance
1	human_development_index	0.638180
0	hospital_beds_per_thousand	0.134692
2	extreme_poverty	0.104035
4	population_density	0.089664
3	gdp_per_capita	0.033430

	feature	importance
0	cardiovasc_death_rate	0.598329
1	diabetes_prevalence	0.185027
5	aged_65_older	0.127458
6	median_age	0.069055
2	female_smokers	0.016719
3	male_smokers	0.002718
4	life_expectancy	0.000695

	feature	importance
0	hospital_beds_per_thousand	0.862863
1	human_development_index	0.112243
2	extreme_poverty	0.019148
3	gdp_per_capita	0.004974
4	population_density	0.000772

	feature	importance
1	diabetes_prevalence	0.793221
0	cardiovasc_death_rate	0.123281
6	median_age	0.063364
2	female_smokers	0.012535
3	male_smokers	0.003768
5	aged_65_older	0.003571
4	life_expectancy	0.000260

	feature	importance
1	human_development_index	0.731394
0	hospital_beds_per_thousand	0.224461
2	extreme_poverty	0.024741
3	gdp_per_capita	0.016963
4	population_density	0.002441

	location	date	cardiovasc_death_rate	diabetes_prevalence	female_smokers	male_smokers	life_expectancy	aged_65_older	median_age	Mortality Rate
6249	Estonia	1/6/2020	255.569	4.02	24.5	39.3	78.74	19.452	42.7	0.000000
6250	Estonia	1/18/2020	255.569	4.02	24.5	39.3	78.74	19.452	42.7	0.000000
6251	Estonia	2/5/2020	255.569	4.02	24.5	39.3	78.74	19.452	42.7	0.000000
6252	Estonia	2/6/2020	255.569	4.02	24.5	39.3	78.74	19.452	42.7	0.000000
6253	Estonia	2/7/2020	255.569	4.02	24.5	39.3	78.74	19.452	42.7	0.000000
...	...	...	...	...	...	...	...	...	...	...
20906	Latvia	12/25/2022	350.060	4.91	25.6	51.0	75.29	19.754	43.9	0.631631
20907	Latvia	12/26/2022	350.060	4.91	25.6	51.0	75.29	19.754	43.9	0.631631
20908	Latvia	12/27/2022	350.060	4.91	25.6	51.0	75.29	19.754	43.9	0.631485
20909	Latvia	12/28/2022	350.060	4.91	25.6	51.0	75.29	19.754	43.9	0.631485
20910	Latvia	12/29/2022	350.060	4.91	25.6	51.0	75.29	19.754	43.9	0.631969

	feature	importance
1	diabetes_prevalence	0.764753
0	cardiovasc_death_rate	0.126479
5	aged_65_older	0.055045
6	median_age	0.033800
2	female_smokers	0.018890
3	male_smokers	0.000750
4	life_expectancy	0.000282

	feature	importance
1	human_development_index	0.587121
0	hospital_beds_per_thousand	0.383466
2	extreme_poverty	0.025717
3	gdp_per_capita	0.003274
4	population_density	0.000422

	location	date	cardiovasc_death_rate	diabetes_prevalence	female_smokers	male_smokers	life_expectancy	aged_65_older	median_age	Mortality Rate
7310	Finland	1/29/2020	153.507	5.76	18.3	22.6	81.91	21.228	42.8	0.00000
7311	Finland	1/30/2020	153.507	5.76	18.3	22.6	81.91	21.228	42.8	0.00000
7312	Finland	1/31/2020	153.507	5.76	18.3	22.6	81.91	21.228	42.8	0.00000
7313	Finland	2/1/2020	153.507	5.76	18.3	22.6	81.91	21.228	42.8	0.00000
7314	Finland	2/2/2020	153.507	5.76	18.3	22.6	81.91	21.228	42.8	0.00000
...	...	...	...	...	...	...	...	...	...	...
21942	Iceland	12/25/2022	117.992	5.31	14.3	15.2	82.99	14.431	37.3	0.11011
21943	Iceland	12/26/2022	117.992	5.31	14.3	15.2	82.99	14.431	37.3	0.11011
21944	Iceland	12/27/2022	117.992	5.31	14.3	15.2	82.99	14.431	37.3	0.11011
21945	Iceland	12/28/2022	117.992	5.31	14.3	15.2	82.99	14.431	37.3	0.11011
21946	Iceland	12/29/2022	117.992	5.31	14.3	15.2	82.99	14.431	37.3	0.11011

	feature	importance
1	diabetes_prevalence	0.424154
0	cardiovasc_death_rate	0.346029
2	female_smokers	0.087274
5	aged_65_older	0.081840
6	median_age	0.050001
3	male_smokers	0.008944
4	life_expectancy	0.001758

	feature	importance
0	hospital_beds_per_thousand	0.747794
1	human_development_index	0.228597
3	gdp_per_capita	0.010147
2	extreme_poverty	0.009692
4	population_density	0.003770

	location	date	cardiovasc_death_rate	diabetes_prevalence	female_smokers	male_smokers	life_expectancy	aged_65_older	median_age	Mortality Rate
8376	France	1/24/2020	86.060	4.77	30.1	35.6	82.66	19.718	42.0	0.000000
8377	France	1/25/2020	86.060	4.77	30.1	35.6	82.66	19.718	42.0	0.000000
8378	France	1/26/2020	86.060	4.77	30.1	35.6	82.66	19.718	42.0	0.000000
8379	France	1/27/2020	86.060	4.77	30.1	35.6	82.66	19.718	42.0	0.000000
8380	France	1/28/2020	86.060	4.77	30.1	35.6	82.66	19.718	42.0	0.000000
...	...	...	...	...	...	...	...	...	...	...
23006	Italy	12/25/2022	113.151	4.78	19.8	27.8	83.51	23.021	47.9	0.735109
23007	Italy	12/26/2022	113.151	4.78	19.8	27.8	83.51	23.021	47.9	0.735109
23008	Italy	12/27/2022	113.151	4.78	19.8	27.8	83.51	23.021	47.9	0.735109
23009	Italy	12/28/2022	113.151	4.78	19.8	27.8	83.51	23.021	47.9	0.735109
23010	Italy	12/29/2022	113.151	4.78	19.8	27.8	83.51	23.021	47.9	0.735109

	feature	importance
1	diabetes_prevalence	0.900030
6	median_age	0.037244
2	female_smokers	0.028587
5	aged_65_older	0.015186
0	cardiovasc_death_rate	0.009428
3	male_smokers	0.006895
4	life_expectancy	0.002631

	feature	importance
1	human_development_index	0.804554
0	hospital_beds_per_thousand	0.079309
4	population_density	0.068506
2	extreme_poverty	0.039535
3	gdp_per_capita	0.008096

	location	date	cardiovasc_death_rate	diabetes_prevalence	female_smokers	male_smokers	life_expectancy	aged_65_older	median_age	Mortality Rate
9447	Netherlands	2/27/2020	109.361	5.29	24.4	27.3	82.28	18.779	43.2	0.000000
9448	Netherlands	2/28/2020	109.361	5.29	24.4	27.3	82.28	18.779	43.2	0.000000
9449	Netherlands	2/29/2020	109.361	5.29	24.4	27.3	82.28	18.779	43.2	0.000000
9450	Netherlands	3/1/2020	109.361	5.29	24.4	27.3	82.28	18.779	43.2	0.000000
9451	Netherlands	3/2/2020	109.361	5.29	24.4	27.3	82.28	18.779	43.2	0.000000
...	...	...	...	...	...	...	...	...	...	...
24069	Sweden	12/25/2022	133.982	4.79	18.8	18.9	82.80	19.985	41.0	0.811466
24070	Sweden	12/26/2022	133.982	4.79	18.8	18.9	82.80	19.985	41.0	0.811466
24071	Sweden	12/27/2022	133.982	4.79	18.8	18.9	82.80	19.985	41.0	0.811466
24072	Sweden	12/28/2022	133.982	4.79	18.8	18.9	82.80	19.985	41.0	0.811466
24073	Sweden	12/29/2022	133.982	4.79	18.8	18.9	82.80	19.985	41.0	0.816005

	feature	importance
1	diabetes_prevalence	0.788294
2	female_smokers	0.150990
6	median_age	0.023584
0	cardiovasc_death_rate	0.017991
3	male_smokers	0.017966
5	aged_65_older	0.000835
4	life_expectancy	0.000340

	feature	importance
1	human_development_index	0.551596
2	extreme_poverty	0.253784
0	hospital_beds_per_thousand	0.164178
3	gdp_per_capita	0.029412
4	population_density	0.001030

	location	date	cardiovasc_death_rate	diabetes_prevalence	female_smokers	male_smokers	life_expectancy	aged_65_older	median_age	Mortality Rate
10484	Portugal	3/1/2020	127.842	9.85	16.3	30.0	82.05	21.502	46.2	0.000000
10485	Portugal	3/2/2020	127.842	9.85	16.3	30.0	82.05	21.502	46.2	0.000000
10486	Portugal	3/3/2020	127.842	9.85	16.3	30.0	82.05	21.502	46.2	0.000000
10487	Portugal	3/4/2020	127.842	9.85	16.3	30.0	82.05	21.502	46.2	0.000000
10488	Portugal	3/5/2020	127.842	9.85	16.3	30.0	82.05	21.502	46.2	0.000000
...	...	...	...	...	...	...	...	...	...	...
25132	Spain	12/25/2022	99.403	7.17	27.4	31.4	83.56	19.436	45.5	0.855148
25133	Spain	12/26/2022	99.403	7.17	27.4	31.4	83.56	19.436	45.5	0.855148
25134	Spain	12/27/2022	99.403	7.17	27.4	31.4	83.56	19.436	45.5	0.855148
25135	Spain	12/28/2022	99.403	7.17	27.4	31.4	83.56	19.436	45.5	0.855148
25136	Spain	12/29/2022	99.403	7.17	27.4	31.4	83.56	19.436	45.5	0.855148

	feature	importance
5	aged_65_older	0.558126
0	cardiovasc_death_rate	0.307971
1	diabetes_prevalence	0.111634
2	female_smokers	0.018149
3	male_smokers	0.003648
6	median_age	0.000360
4	life_expectancy	0.000112

	feature	importance
1	human_development_index	0.528876
0	hospital_beds_per_thousand	0.437493
2	extreme_poverty	0.029621
3	gdp_per_capita	0.003685
4	population_density	0.000326